﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Ledict.ConditionExtract.Common;
using Ledict.ConditionExtract.Enum;
using Ledict.ConditionExtract.Model;
using Ledict.Utility.Extension;
using Ledict.Utility.Helper;

namespace Ledict.ConditionExtract.BLL.WorkProcess
{
    /// <summary>
    /// 民事（第一次处理）
    /// </summary>
    /// <remarks>
    /// 民事跑表述的规则（建议后来者先看此规则）
    /// 
    /// 保留徐仁娜的部分刑事处理逻辑，加入大量民事的自定义规则，不具有普遍性
    /// 民事跑表述规则：
    /// 1.争议焦点要素（哪些节点跑单一和组合，在配置文件中有设置，实现动态配置，以防止需求人员后期随意变更需求时的应变，zhangpeng） 跑组合和单一，其他节点只跑单一  
    /// 2.单一的条件：
    ///    单一规则：
    ///    a.符合本节点，不符合子节点和不符合同级节点规则的逻辑段，即为该节点的单一表述（适用于组合和单一都要跑的节点）
    ///    b.符合本节点，则继续跑本节点的子节点，符合子节点，则本节点不挂。按此规则，循环递归跑完所有节点。(适用只跑单一的节点)
    ///    c.判断该节点是否是“争议焦点要素”，如果是：则跑单一和组合，如果否：只跑单一
    /// 3.组合的条件：按照需求人员的要求，阐述如下（但该规则没有普遍性，程序无法按此规则设计成通用程序，只适用于民事下的争议焦点要素该节点，后期需求如果有改动，则只能听之任之，后来者知悉 add by zhangpeng 2017-01-12）
    ///     a.在指定节点范围内，在此以争议焦点要素为例，一条表述按照父子关系，层层往下跑，如果符合父级规则，则继续往下漏，
    ///       当跑到最后一级如果符合，则去匹配该节点的父级的同级节点，如果也符合，则跑到符合的同级节点的子节点，如果子节点符合，并且名称与第一个子节点的名称一样，则他俩的父节点组合，表述挂到子节点上
    ///       如：‘111’这条表述既符合，按月提供物业合同下的支持物业，也符合符合法律规定下的支持物业，则组合‘按月提供物业合同+符合法律规定’，同时表述挂在组合节点下的支持物业上。
    ///     b.能组合的节点节点的父节点一定是同一个节点，不能越级，组合节点都是平级，不同于刑事的层层往下组合。
    ///       如：&lt;按约提供物业合同&gt;和&lt;符合法律规定&gt;两个节点的子节点名称相同，并且表述都符合子节点的规则，同时这两个节点的父节点是同一节点，则这两个节点才可以组合
    ///     c.民事的需求，自己认为很不合理，但也只能这样定制化的实现，没有复用性可言，后来者知悉即可。add by zhangpeng 2017-01-12
    /// </remarks>
    public class WorkThread_first_People : WorkThread_first
    {
        #region 全局变量

        public int MaxCount = 0; //处理总数
        private int CurrentCount = 0; //处理当前数量

        protected TreeDataBLL trbll = new TreeDataBLL();
        protected Express_WordBLL wordbll = new Express_WordBLL();
        protected Express_AddElement addelementbll = new Express_AddElement();
        protected ExpressGroupSituationBLL expresitu = new ExpressGroupSituationBLL();
        protected Express_MatchSituationBLL match = new Express_MatchSituationBLL();
        protected AboutRegexBLL aboutreg = new AboutRegexBLL();
        protected RegexParse.RegexParse getregex = new RegexParse.RegexParse();
        protected ProcessDataSourceBLL datas = new ProcessDataSourceBLL();
        protected WorkThread_Public work = new WorkThread_Public();
        protected XmlLabel_LabelRelBLL xmlLabel_LabelRelBLL = new XmlLabel_LabelRelBLL();
        //private CaseCauseBLL casecausebll = new CaseCauseBLL();
        private StaticCacheBLL staticcache = new StaticCacheBLL();
        private CaseCauseBLL ccbll = new CaseCauseBLL();
        //Express_MatchSituationBLL MatchSituationbll = new Express_MatchSituationBLL();
        //WordBankKeyWordsBLL wordbankkeywordsbll = new WordBankKeyWordsBLL();
        private NewIDBLL newid = new NewIDBLL();
        //Express_WordBankRelBLL express_wordbankrelbll = new Express_WordBankRelBLL();

        #endregion

        #region 准备开始

        /// <summary>
        /// 开始加工（一个案由）
        /// </summary>
        public override void execute_Start()
        {
            //打开缓存
            getregex.StartCache();
            //查询案由的案由路径
            conditon.HeadwordId = trbll.GetHeadWordAllPid(conditon.HeadwordId);
            MaxCount = 0;
            CurrentCount = 0;
            //2、待处理的数据
            MaxCount += GetDataSourceCount(conditon);

            // 没数据结束进度条
            if (MaxCount == 0) //没有可以跑数据的案例
            {
                if (MaxCount >= CurrentCount)
                {
                    processShow(MaxCount, CurrentCount);
                }
            }
            else //加工数据
            {
                execute_Condition1(conditon);
            }
            //关闭缓存
            getregex.EndCache();
        }

        #endregion

        #region  准备条件和数据

        /// <summary>
        /// 加工数据
        /// 1、根据节点删除表述关系及其表述内容（未打对勾的）
        /// 1、由“查询条件”（condition）查询lucene索引，得到“表述”，也就是逻辑段
        /// 2、由“处理节点”(condition.SituationId)获得“情形情节分组”(如：犯罪相关情形、法定情节)
        /// 3、由“情形情节分组”（2的结果）查询数据库，得到节点的范围   (如：犯罪相关情形的所有下级节点) 
        /// 4、匹配数据。过程：用“表述”（1的结果）匹配“节点”（3的结果），得出结果，结果如：
        ///    盗窃数额较大(单一)            --被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。
        ///    盗窃数额较大+结伙盗窃（组合） --被告人伙同他人秘密窃取公私财物，数额较大，其行为已构成盗窃罪，依法应予惩处。
        /// 5、匹配后的结果入库。
        ///    表述节点（如：盗窃数额较大、盗窃数额较大+结伙盗窃）存入SYS_Express_MatchSituation
        ///    表述文本（如：被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。）存入SYS_Express_Word_Process
        ///    
        ///  1、根据节点删除表述关系及其表述内容（未打对勾的）
        ///  2、由界面查询条件查索引得到表述集合
        ///  3、由界面输入的节点查询“情形情节分组”的节点组合，得到需要处理的节点的范围
        ///  4、匹配数据 用表述集合中的表述去匹配节点的数据
        ///  5、匹配后的结果入库
        ///   如：  表述节点（如：盗窃数额较大、盗窃数额较大+结伙盗窃）存入SYS_Express_MatchSituation
        ///    表述文本（如：被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。）存入SYS_Express_Word_Process
        ///    匹配规则：
        ///    1.单一的条件：
        ///    单一规则：
        ///     符合本节点，不符合子节点和不符合同级节点规则的逻辑段，即为该节点的单一表述
        ///         
        ///   2.组合的条件：按照需求人员的要求，阐述如下
        ///     a.在指定节点范围内，在此以争议焦点要素为例，一条表述按照父子关系，层层往下跑，如果符合父级规则，则继续往下漏，
        ///       当跑到最后一级如果符合，则去匹配该节点的父级的同级节点，如果也符合，则跑到符合的同级节点的子节点，如果子节点符合，并且名称与第一个子节点的名称一样，则他俩的父节点组合，表述挂到子节点上
        ///       如：‘111’这条表述既符合，按月提供物业合同下的支持物业，也符合符合法律规定下的支持物业，则组合‘按月提供物业合同+符合法律规定’，同时表述挂在组合节点下的支持物业上。
        ///     b.能组合的节点节点的父节点一定是同一个节点，不能越级，组合节点都是平级，不同于刑事的层层往下组合。
        ///       如：按约提供物业合同和符合法律规定两个节点的子节点名称相同，并且表述都符合子节点的规则，同时这两个节点的父节点是同一节点，则这两个节点才可以组合
        /// </summary>
        /// <param name="condition">条件</param>
        public virtual void execute_Condition1(DataSourceCondition condition) //案由ID
        {
            try
            {
                int perPage = condition.SearchPerSize; //每次从索引取5000条
                int page = (int)Math.Ceiling((double)MaxCount / perPage); //多少页

                DataTable caseiddt; //分页数据源集合

                //2.获取需要匹配的案由下的情节情形的数据
                DataTable dt = work.BelongCaseCauseId(condition.SituationId);
                DataTable processNodedt = new DataTable();
                if (dt != null && dt.Rows.Count > 0)
                {                   
                    processNodedt = dt;
                }
                else
                {
                    MessageBox.Show("没有需要处理的节点");
                    return;
                }

                #region 分页

                wordbll.DeleteSYS_Express_Word_ProcessMinshi(condition.SituationId);

                    //分页
                for (int pag = 1; pag <= page; pag++)
                {
                    //1.由“查询条件”（condition）查询lucene索引，得到“表述”
                    caseiddt = GetDataSource(condition, pag, perPage); //案由ID的相关文本数据(得到Caseid)                                        
                    //DataTable dttt = caseiddt.Select("CaseId='3592083'").CopyToDataTable<DataRow>();
                    //caseiddt.Select("ParagraphText='经审理查明：董XX与苏XX原系夫妻关系，双方于2005年7月4日生育一子苏X，2012年10月9日董XX与苏XX自愿达成离婚协议，协议约定：苏X归男方抚养，由女方照顾共同生活至18周岁，男方每月支付生活费500元，教育费、医疗费、保险费用根据凭证双方各承担50 % 至苏X独立生活止。'");

                    //循环数据
                    for (int i = 0; i < caseiddt.Rows.Count; i++)
                    {
                        string processNodeId = ""; //小单元起始处
                        string paragraphTypeId = ""; //逻辑段类型ID
                        string id = ""; // 表述ID
                        string caseid = ""; //案例ID
                        string paragraphText = ""; //
                                                   //string paragraphId = "";


                        for (int p = 0; p < processNodedt.Rows.Count; p++) //小单元
                        {
                            if (pag == 1) //添加组合单一节点
                            {
                                work.AddMatch_virtual("S" + processNodedt.Rows[p]["CC_ID"].ToString(), "单一");
                                //if (processNodedt.Rows[p]["CC_Name"].ToString().Contains("争议焦点要素"))
                                //{
                                work.AddMatch_virtual("M" + processNodedt.Rows[p]["CC_ID"].ToString(), "组合");
                                //}
                            }
                            //CCID
                            processNodeId = processNodedt.Rows[p]["CC_ID"].ToString(); //节点开始处
                                                                                       //逻辑段
                            paragraphTypeId = caseiddt.Rows[i]["ParagraphTypeId"].ToString();
                            //case主键ID
                            id = caseiddt.Rows[i]["id"].ToString();
                            //caseID
                            caseid = caseiddt.Rows[i]["CaseId"].ToString();
                            //案例文本
                            paragraphText = caseiddt.Rows[i]["ParagraphText"].ToString();

                            DataTable conditiondt = staticcache.GetHeadwordData(processNodeId, processNodedt.Rows[p]["CC_ParentID"].ToString());//节点信息集合 

                            #region 提前筛选数据 尽可能匹配当前节点的表述，不符合要求的直接舍弃
                            //bool flog = true;
                            //DataRow[] arrayDrPro = conditiondt.Select("CC_ID='" + condition.SituationId + "'");
                            //if (arrayDrPro.Any() && Convert.ToInt32(arrayDrPro[0]["RegCount"].ToString()) > 0)//有正则
                            //{
                            //    flog = IsMatch(paragraphText, arrayDrPro[0]["CC_RegexInfoCode"].ToString()) > 0;
                            //}
                            #endregion 提前筛选数据

                            //if (flog)
                            //{
                                //4.匹配数据
                                execute_Match(paragraphText, caseid, paragraphTypeId, processNodeId, conditiondt, condition.IsHasOwnNode);
                            //}
                        }
                        CurrentCount++; // 显示进度条
                        if (MaxCount >= CurrentCount)
                        {
                            processShow(MaxCount, CurrentCount);
                        }
                        //bool flog = false;
                        ////包含本节点
                        //if (condition.IsHasOwnNode)
                        //{
                        //    var currentDt = staticcache.GetCurrentCivilHeadwordData(condition.SituationId, condition.OperatePurposeId, condition.OperateParagraphId, true);

                        //    if (currentDt != null && currentDt.Rows.Count > 0 && Convert.ToInt32(currentDt.Rows[0]["RegCount"].ToString()) > 0)//有正则
                        //    {
                        //        flog = IsMatch(paragraphText, currentDt.Rows[0]["CC_RegexInfoCode"].ToString()) > 0;
                        //        if (flog)
                        //        {
                        //            paragraphText = strMatch(paragraphText, currentDt.Rows[0]["CC_RegexInfoCode"].ToString());
                        //        }
                        //    }

                        //}

                        //if ((condition.IsHasOwnNode && flog) || !condition.IsHasOwnNode)
                        //{
                        //    //3.由“情形情节分组”（2的结果）查询数据库，得到节点的范围   (如：犯罪相关情形的所有下级节点)
                        //    //todo by zhangpeng:新需求，如果查询条件有用途和逻辑段，则查询节点中对应的用途和逻辑段的正则规则进行匹配，如果没有，则全局匹配
                        //    //所有小分组的所有下级并排序,通过ccid，用途id和逻辑段ID
                        //    conditiondt = staticcache.GetCivilHeadwordData(processNodeId, condition.OperatePurposeId,
                        //        condition.OperateParagraphId);


                        //    //判断该节点是否是“争议焦点要素”（该节点的名称用配置文件管理，实现动态化，不一定必须是“争议焦点要素”），如果是：则跑单一和组合，如果否：只跑单一
                        //    //todo by zhangpeng:以上为民事的特殊要求

                        //    //需要跑单一和组合的节点列表
                        //    var strOneAndCombination = ConfigHelper.AppSettings("CivilMatchOneAndCombination");
                        //    //为空，则只跑单一的单一规则
                        //    if (string.IsNullOrEmpty(strOneAndCombination))
                        //    {
                        //        ExecuteMatchOne(paragraphText, caseid, paragraphTypeId, processNodeId, conditiondt);
                        //    }
                        //    else //组合和单一混合跑
                        //    {
                        //        var strArray = strOneAndCombination.Split(new string[] { "," },
                        //            StringSplitOptions.RemoveEmptyEntries);

                        //        //单一和组合
                        //        if (strArray.Contains(processNodedt.Rows[p]["CC_Name"].ToString()))
                        //        {
                        //            //单一和组合
                        //            //4.匹配数据
                        //            execute_Match(paragraphText, caseid, paragraphTypeId, processNodeId, conditiondt, condition.IsHasOwnNode);
                        //        }
                        //        else //只跑单一规则
                        //        {
                        //            ExecuteMatchOne(paragraphText, caseid, paragraphTypeId, processNodeId,
                        //                conditiondt);
                        //        }
                        //    }
                        //}

                        #region 处理完成后,进度条

                        CurrentCount++; // 显示进度条
                        if (MaxCount >= CurrentCount)
                        {
                            processShow(MaxCount, CurrentCount);
                        }

                        int innercurrentcout = Interlocked.Add(ref this.CurrentCount, 1);
                        if (this.MaxCount >= innercurrentcout)
                        {
                            this.processShow(this.MaxCount, innercurrentcout);
                        }

                        lockObj.WaitOne();
                        if (readyToClose)
                        {
                        }
                    }
                    #endregion 处理完成后,进度条
                    //});
                }

                #endregion 分页

                //关闭
                if (readyToClose)
                {
                    closeForm();
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }





        /// <summary>
        /// 加工数据
        /// 1、由“查询条件”（condition）查询lucene索引，得到“表述”，也就是逻辑段
        /// 2、由“处理节点”(condition.SituationId)获得“情形情节分组”(如：犯罪相关情形、法定情节)
        /// 3、由“情形情节分组”（2的结果）查询数据库，得到节点的范围   (如：犯罪相关情形的所有下级节点)
        /// 4、匹配数据。过程：用“表述”（1的结果）匹配“节点”（3的结果），得出结果，结果如：
        ///    盗窃数额较大(单一)            --被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。
        ///    盗窃数额较大+结伙盗窃（组合） --被告人伙同他人秘密窃取公私财物，数额较大，其行为已构成盗窃罪，依法应予惩处。
        /// 5、匹配后的结果入库。
        ///    表述节点（如：盗窃数额较大、盗窃数额较大+结伙盗窃）存入SYS_Express_MatchSituation
        ///    表述文本（如：被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。）存入SYS_Express_Word_Process
        /// </summary>
        /// <param name="condition">条件</param>
        public virtual void execute_Condition(DataSourceCondition condition) //案由ID
        {
            int perPage = condition.SearchPerSize; //每次从索引取5000条
            int page = (int)Math.Ceiling((double)MaxCount / perPage); //多少页

            DataTable caseiddt; //分页数据源集合

            //2.节点匹配数据开始处
            //返回案由节点
            DataTable processNodedt = work.CivilBelongCaseCauseId(condition.SituationId);
            //DataTable processNodedt = work.BelongCaseCauseId(condition.SituationId);

            #region 分页

            //分页
            for (int pag = 1; pag <= page; pag++)
            {
                //1.由“查询条件”（condition）查询lucene索引，得到“表述”
                caseiddt = GetDataSource(condition, pag, perPage); //案由ID的相关文本数据(得到Caseid)
                DataTable dttt = caseiddt.Select("CaseId='1000228'").CopyToDataTable<DataRow>();
                caseiddt.Select("ParagraphText='经审理查明：董XX与苏XX原系夫妻关系，双方于2005年7月4日生育一子苏X，2012年10月9日董XX与苏XX自愿达成离婚协议，协议约定：苏X归男方抚养，由女方照顾共同生活至18周岁，男方每月支付生活费500元，教育费、医疗费、保险费用根据凭证双方各承担50 % 至苏X独立生活止。'");
                //IEnumerable<DataRow> caseidenumerable = caseiddt.Rows.Cast<DataRow>();

                //int indextemp = -1;

                //循环案例逻辑段（索引数据）
                //Parallel.ForEach(caseidenumerable, new ParallelOptions
                //{
                //    /* Ldt.JudgeDoc.Data.Config.SysConfig.ParallerMaxLength */
                //    MaxDegreeOfParallelism = 1
                //},
                //    row =>
                //    {
                //        int k = Interlocked.Add(ref indextemp, 1);
                for (int i = 0; i < caseiddt.Rows.Count; i++)
                {
                    string processNodeId = ""; //小单元起始处
                    string paragraphTypeId = ""; //逻辑段类型ID
                    string id = ""; // 表述ID
                    string caseid = ""; //案例ID
                    string paragraphText = ""; //
                                               //string paragraphId = "";
                    DataTable conditiondt; //节点信息集合


                    for (int p = 0; p < processNodedt.Rows.Count; p++) //小单元
                    {
                        if (pag == 1) //添加组合单一节点
                        {
                            work.AddMatch_virtual("S" + processNodedt.Rows[p]["CC_ID"].ToString(), "单一");
                            if (processNodedt.Rows[p]["CC_Name"].ToString().Contains("争议焦点要素"))
                            {
                                work.AddMatch_virtual("M" + processNodedt.Rows[p]["CC_ID"].ToString(), "组合");
                            }
                        }

                        processNodeId = processNodedt.Rows[p]["CC_ID"].ToString(); //节点开始处
                        paragraphTypeId = caseiddt.Rows[i]["ParagraphTypeId"].ToString();
                        id = caseiddt.Rows[i]["id"].ToString();
                        caseid = caseiddt.Rows[i]["CaseId"].ToString();
                        paragraphText = caseiddt.Rows[i]["ParagraphText"].ToString();
                        //???
                        //if (caseid != "4817542")
                        //{
                        //    continue;
                        //}
                        //  paragraphText = caseiddt.Rows[k]["ParagraphText"].ToString();
                        //paragraphText = "本院认为：华隆公司与郑有兴签订的前期物业管理服务协议，系其真实意思表示，内容亦不违反法律、行政法规禁止性规定，该合同合法有效，当事人应当遵循诚实信用原则按照约定履行自己的义务。本案的争议焦点有：1.郑有兴应以什么标准向华隆公司支付物业管理服务费，华隆公司主张郑有兴向其支付违约金的诉求能否得到支持，原告与天津市河北区金田公寓业主会签订的《天津市住宅物业服务合同》合法有效，应予认定；";

                        //todo by zhangpeng 2016-12-23 民事不需要隐私处理
                        //paragraphText = Privacy(paragraphText, caseid);//隐私处理
                        //                            paragraphText =@"原告诉称，原告系被告所居住小区的物业服务公司，2013年6月5日被告小区的业主委员会与原告正式签订物业服务合同。被告系该小区4号楼3单元301室业主，面积为97.58平方米，每平方米物业费0.3元，每月29.30元。2013年7月至2014年5月，被告共拖欠11个月物业费，共计322.30元。经原告多次催要，被告以种种理由拒绝给付，故原告诉至法院，请求法院判令被告立即给付拖欠的物业费322.30元并承担本案的诉讼费。
                        //                                    被告辩称，被告没有签过物业合同，不清楚业主委员会是如何产生的，被告单元的业主也没有参加过选举业主委员会成员。对原告的合法性存在怀疑。被告所居住的单元没有交物业费的，不清楚物业服务的项目及收费标准是谁与原告订立的，收费标准的依据是什么。被告家暖气跑水了，原告不管，被告停在楼道门前的车上的四个轮子及物品丢失了，原告也不管，楼道内存放杂物，原告也不管。小区内五个门全都是敞开的，没有进行封闭管理。小区内存在多种经营场所，严重扰民，平时也找不到原告公司的人。原告也不管小区内的绿化、美化。物业清洁人员年龄偏大，不能正常工作。小区内部分单元的居民在绿化带内种植蔬菜，物业的人员说是弃管了，小区内的石桌、石凳及雕塑也都没有了，原告公司不管，楼道内的墙面上乱涂乱画也没人管，不清楚物业公司管什么，物业服务的内容及收费标准没有向被告说明，同一个小区，不同待遇。被告认可楼道确实是打扫了，所以被告可以交清扫费，但不同意交物业费。被告家面积确实是97.58平方米。
                        //                                    本案的争议焦点为：原告的诉讼请求有无事实及法律依据
                        //                                    针对自己的主张，原告向本院提交物业服务合同一份，证明原告与被告小区的业主委员会签订了物业合同，约定每平方米交纳3毛钱费用，但被告未按时交纳。
                        //                                    被告对该证据的质证意见是对真实性有异议。业主没有选举过业主委员会，所以不认可业主委员会签订的合同，被告本人也没有签过物业合同。
                        //                                    被告未向本院提交证据。
                        //                                    根据原告起诉、被告答辩，原、被告举证、质证，下列事实可以认定：2013年6月5日，原告与红星教师新村业主委员会签订了一份红星教师新村物业服务合同，合同约定红星教师新村周边的7栋住宅楼交由原告进行物业管理，并约定了服务的内容及标准，物业费的标准（多层住宅0.3元/月/平方米）等内容。2014年5月31日，原告与红星教师新村业主委员会签订了一份红星教师新村物业服务合同补充协议，合同第2条约定：“甲、乙双方最终确定物业服务的管理区域为：教师新村1号、2号、3号、4号、5号、6号、7号、8号楼。”被告现居住在红星教师新村4号楼3单元301室，房屋面积为97.58平方米。原告自2013年7月至2014年5月未向原告交纳物业费。
                        //                                    现根据本院认定的事实及庭审中双方当事人的举证、质证，结合相关法律规定，针对争议焦点，本院综合评判如下：
                        //                                    《最高人民法院关于审理物业服务纠纷案件具体应用法律若干问题的解释》第一条的规定：“建设单位依法与物业服务企业签订的前期物业服务合同，以及业主委员会与业主大会依法选聘的物业服务企业签订的物业服务合同，对业主具有约束力。业主以其并非合同当事人为由提出抗辩的，人民法院不予支持。”原告与红星教师新村业主委员会签订的物业服务合同对所有业主应当具有约束力。根据《物业管理条例》第四十二条：“业主应当根据物业服务合同的约定交纳物业服务费用。业主与物业使用人约定由物业使用人交纳物业服务费用的，从其约定，业主负连带交纳责任。”的规定，被告应当按照合同约定履行交纳物业费的义务。被告所居住的房屋为97.58平方米，应当交纳2013年7月至2014年5月的物业费322.30元（97.58平方米0.30元/平方米/月11个月=322.30元）。如被告确有证据证明原告未按物业服务合同的约定履行维修、养护、管理和维护义务或造成损失，其可依据相关法律规定，向人民法院另案提起诉讼。";
                        //if (!string.IsNullOrEmpty(condition.OperatePurposeId) &&
                        //    !string.IsNullOrEmpty(condition.OperateParagraphId))
                        //{
                        //    //所有小分组的所有下级并排序,通过ccid，用途id和逻辑段ID
                        //    conditiondt = staticcache.GetCivilHeadwordData(processNodeId, condition.OperatePurposeId,
                        //        condition.OperateParagraphId);
                        //}
                        //else
                        //{
                        //    conditiondt = staticcache.GetCivilHeadwordData(processNodeId); //所有小分组的所有下级并排序
                        //}

                        /*处理节点中是否包含当前选中节点，如果包含，则表述必须先跑这个节点，
                         * 符合指定正则规则后，方可继续下级，否则直接跳过这条表述 
                         */
                        bool flog = false;
                        //包含本节点
                        if (condition.IsHasOwnNode)
                        {
                            var currentDt = staticcache.GetCurrentCivilHeadwordData(condition.SituationId, condition.OperatePurposeId,condition.OperateParagraphId, true);

                            if (currentDt != null && currentDt.Rows.Count > 0 && Convert.ToInt32(currentDt.Rows[0]["RegCount"].ToString()) > 0)//有正则
                            {
                                flog = IsMatch(paragraphText, currentDt.Rows[0]["CC_RegexInfoCode"].ToString()) > 0;
                                if (flog)
                                {
                                    paragraphText = strMatch(paragraphText, currentDt.Rows[0]["CC_RegexInfoCode"].ToString());
                                }
                            }

                        }

                        if ((condition.IsHasOwnNode && flog) || !condition.IsHasOwnNode)
                        {
                            //3.由“情形情节分组”（2的结果）查询数据库，得到节点的范围   (如：犯罪相关情形的所有下级节点)
                            //todo by zhangpeng:新需求，如果查询条件有用途和逻辑段，则查询节点中对应的用途和逻辑段的正则规则进行匹配，如果没有，则全局匹配
                            //所有小分组的所有下级并排序,通过ccid，用途id和逻辑段ID
                            conditiondt = staticcache.GetCivilHeadwordData(processNodeId, condition.OperatePurposeId,
                                condition.OperateParagraphId);


                            //判断该节点是否是“争议焦点要素”（该节点的名称用配置文件管理，实现动态化，不一定必须是“争议焦点要素”），如果是：则跑单一和组合，如果否：只跑单一
                            //todo by zhangpeng:以上为民事的特殊要求

                            //需要跑单一和组合的节点列表
                            var strOneAndCombination = ConfigHelper.AppSettings("CivilMatchOneAndCombination");
                            //为空，则只跑单一的单一规则
                            if (string.IsNullOrEmpty(strOneAndCombination))
                            {
                                ExecuteMatchOne(paragraphText, caseid, paragraphTypeId, processNodeId, conditiondt);
                            }
                            else //组合和单一混合跑
                            {
                                var strArray = strOneAndCombination.Split(new string[] { "," },
                                    StringSplitOptions.RemoveEmptyEntries);

                                //单一和组合
                                if (strArray.Contains(processNodedt.Rows[p]["CC_Name"].ToString()))
                                {
                                    //单一和组合
                                    //4.匹配数据
                                    execute_Match(paragraphText, caseid, paragraphTypeId, processNodeId, conditiondt, condition.IsHasOwnNode);
                                }
                                else //只跑单一规则
                                {
                                    ExecuteMatchOne(paragraphText, caseid, paragraphTypeId, processNodeId,
                                        conditiondt);
                                }
                            }
                        }
                    }

                    #region 处理完成后,进度条

                    CurrentCount++; // 显示进度条
                    if (MaxCount >= CurrentCount)
                    {
                        processShow(MaxCount, CurrentCount);
                    }

                    int innercurrentcout = Interlocked.Add(ref this.CurrentCount, 1);
                    if (this.MaxCount >= innercurrentcout)
                    {
                        this.processShow(this.MaxCount, innercurrentcout);
                    }

                    lockObj.WaitOne();
                    if (readyToClose)
                    {
                    }
                }
                        #endregion 处理完成后,进度条
                    //});
            }

            #endregion 分页

            //关闭
            if (readyToClose)
            {
                closeForm();
            }
        }

        #endregion

        #region 匹配数据




        #region 单一匹配(非配置文件中的节点)

        /// <summary>
        /// 跑单一表述(单一的条件：符合本节点，则继续跑本节点的子节点，符合子节点，则本节点不挂。按此规则，循环递归跑完所有节点。)
        /// </summary>
        /// <param name="inputText">逻辑段内容</param>
        /// <param name="caseid">案例ID</param>
        /// <param name="paragraphTypeId">逻辑段类型ID</param>
        /// <param name="caseCauseId">ccId</param>
        /// <param name="conditiondt">ccid下的节点的范围</param>
        public void ExecuteMatchOne(string inputText, string caseid, string paragraphTypeId, string caseCauseId,
            DataTable conditiondt)
        {
            //string ccIdList = "";
            string ccRegexInfoCode = "";
            string ccId = "";
            //string ccName = "";
            int regCount = 0;
            int childCount = 0;


            DataRow[] arrayDr = conditiondt.Select("CC_ParentID='" + caseCauseId + "'"); //查找情形分组的下级（如“犯罪相关情形”的下级）

            for (int j = 0; j < arrayDr.Length; j++) //第一级
            {
                string resultText = ""; //总的结果
                string outtext = inputText;
                ccRegexInfoCode = arrayDr[j]["CC_RegexInfoCode"].ToString();
                ccId = arrayDr[j]["CC_ID"].ToString();
                //ccName = arrayDR[j]["CC_Name"].ToString();
                regCount = Convert.ToInt32(arrayDr[j]["RegCount"].ToString());
                childCount = Convert.ToInt32(arrayDr[j]["ChildCount"].ToString());
                //递归匹配子节点和同级节点
                //4、匹配数据。过程：用“表述”（1的结果）匹配“节点”（3的结果），得出结果，结果如：
                // 盗窃数额较大(单一)            --被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。
                MatchChild_One(conditiondt, inputText, ccId, caseCauseId, ccRegexInfoCode, regCount, childCount,
                    ref resultText, ref outtext);

                if (string.IsNullOrEmpty(resultText))
                    continue;
                //5、 匹配后的结果入库。表述节点（如：盗窃数额较大、盗窃数额较大+结伙盗窃）存入SYS_Express_MatchSituation
                // 表述文本（如：被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。）存入SYS_Express_Word_Process
                //string EW_Content = strMatch(inputText, 
                //    conditiondt.Select("CC_ID='" + resultText + "'")[0]["CC_RegexInfoCode"].ToString());
                AddToExpress(resultText, caseid, paragraphTypeId, caseCauseId, resultText, outtext);

            }
        }

        /// <summary>
        /// 匹配子节点（非一层）
        /// </summary>
        /// <param name="conditiondt">节点树</param>
        /// <param name="oneinputText">逻辑段</param>
        /// <param name="ccId">当前节点ID</param>
        /// <param name="parentId">父节点ID</param>
        /// <param name="ccRegexInfoCode">正则编码</param>
        /// <param name="regCount">正则数量</param>
        /// <param name="childCount">子节点数量</param>
        /// <param name="resultText">结果ID字符串</param>
        /// <returns>子节点有匹配项，返回true，否则返回false</returns>
        public bool MatchChild_One(DataTable conditiondt, string oneinputText, string ccId, string parentId,
            string ccRegexInfoCode, int regCount, int childCount, ref string resultText,ref string oneoutText) //CC_ID 及以下是不是有匹配
        {
            int matchNumber = 0;
           // oneoutText = ccRegexInfoCode;

            //没正则，默认不匹配
            //有正则
            if (regCount > 0)
            {
                matchNumber = IsMatch(oneinputText, ccRegexInfoCode);
                if (matchNumber == 1)
                {
                    oneoutText = strMatch(oneinputText, ccRegexInfoCode);
                }
            }
            else //不匹配
            {
                return false;
            }

            #region  匹配

            if (matchNumber == 1) //匹配
            {
                bool child = false; //子级

                //判断当前节点的子节点是否存在匹配项
                //下级不为空
                if (childCount > 0)
                {
                    DataRow[] arrayDr = conditiondt.Select(" CC_ParentID='" + ccId + "' and CC_NodeType<>12 ");
                    for (int i = 0; i < arrayDr.Length; i++)
                    {
                        bool mat = MatchChild_One(conditiondt, oneinputText, arrayDr[i]["CC_ID"].ToString(), ccId,
                            arrayDr[i]["CC_RegexInfoCode"].ToString(),
                            Convert.ToInt32(arrayDr[i]["RegCount"].ToString()),
                            Convert.ToInt32(arrayDr[i]["ChildCount"].ToString()), ref resultText, ref oneoutText);
                        if (mat)
                        {
                            child = true;
                        }
                    }
                }

                if (!child) //下级没有匹配到(没写数据不挂数据)
                {
                    if (resultText == "")
                    {
                        resultText = ccId;
                    }
                    return true;
                }
                return false;
            }

            #endregion

            //不匹配
            return false;
        }

        #endregion

        #region 单一和组合匹配

        /// <summary>
        /// 加工情形、情节
        /// </summary>
        /// <param name="inputText">逻辑段内容</param>
        /// <param name="caseid">案例ID</param>
        /// <param name="paragraphTypeId">逻辑段类型ID</param>
        /// <param name="caseCauseId">ccId</param>
        /// <param name="conditiondt">ccid下的节点的范围</param>
        /// <param name="isHasSelectNode">选中节点是否跑</param>
        public void execute_Match(string inputText, string caseid, string paragraphTypeId, string caseCauseId,
            DataTable conditiondt, bool isHasSelectNode) //第一层情形情节（conditiondt限定规则范围）
        {
            string ccIdList = "";
            string ccRegexInfoCode = "";
            string ccId = "";
            string ccName = "";
            int regCount = 0;
            int childCount = 0;
            string resultText = ""; //总的结果
            string outstr = inputText;//正则匹配结果



            TreeNode treeNode = new TreeNode() { Name = caseCauseId, Tag = ProcessNodeType.Single, Checked = isHasSelectNode };//存放节点结果 新添加的，适用于跑民事

            DataRow[] arrayDr = conditiondt.Select("CC_ParentID='" + caseCauseId + "'"); //查找情形分组的下级（如“犯罪相关情形”的下级）

            for (int j = 0; j < arrayDr.Length; j++) //第一级
            {
                ccRegexInfoCode = arrayDr[j]["CC_RegexInfoCode"].ToString();
                ccId = arrayDr[j]["CC_ID"].ToString();
                ccName = arrayDr[j]["CC_Name"].ToString();
                regCount = Convert.ToInt32(arrayDr[j]["RegCount"].ToString());
                childCount = Convert.ToInt32(arrayDr[j]["ChildCount"].ToString());
                //递归匹配子节点
                //4、匹配数据。过程：用“表述”（1的结果）匹配“节点”（3的结果），得出结果，结果如：
                // 按约提供物业合同(单一)            --被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。
                // 按约提供物业合同+符合法律规定（组合） --被告人伙同他人秘密窃取公私财物，数额较大，其行为已构成盗窃罪，依法应予惩处。
                MatchChild(conditiondt, inputText, ccId, ccName, caseCauseId, ccRegexInfoCode, regCount, childCount, ref resultText, ref treeNode,ref outstr);

            }

            if (resultText != "")
            {
                ccIdList = resultText;

                var ss = treeNode.Nodes;


                //5、 匹配后的结果入库。表述节点（如：盗窃数额较大、盗窃数额较大+结伙盗窃）存入SYS_Express_MatchSituation
                // 表述文本（如：被告人秘密窃取他人财物，数额较大，其行为已构成盗窃罪，依法应予惩处。）存入SYS_Express_Word_Process
                //inputText = strMatch(inputText, conditiondt.Select("CC_ID='" + caseCauseId + "'")[0]["CC_RegexInfoCode"].ToString());
                AddCombinationExpress(outstr, caseid, paragraphTypeId, caseCauseId, ccIdList, treeNode);
            }
        }

        /// <summary>
        /// 匹配子节点（非一层）
        /// </summary>
        /// <param name="conditiondt">跑表述的节点集合</param>
        /// <param name="oneinputText">表述</param>
        /// <param name="ccId">当前节点</param>
        /// <param name="ccName">当前节点名称</param>
        /// <param name="ccIdParentId">当前节点的父节点（用于组合匹配时确定节点范围）</param>
        /// <param name="ccRegexInfoCode">正则code</param>
        /// <param name="regCount">当前节点的正则规则数量</param>
        /// <param name="childCount">当前节点的子节点数量</param>
        /// <param name="resultText">结果集合</param>
        /// <returns></returns>
        public bool MatchChild(DataTable conditiondt, string oneinputText, string ccId, string ccName, string ccIdParentId,
            string ccRegexInfoCode, int regCount, int childCount, ref string resultText, ref TreeNode treeNode,ref string outsr) //CC_ID 及以下是不是有匹配
        {
            int matchNumber = 0;

            //没正则，默认不匹配

            if (regCount > 0) //有正则
            {
                matchNumber = IsMatch(oneinputText, ccRegexInfoCode);
                if (matchNumber == 1)
                {
                    outsr = oneinputText;
                      // outsr = strMatch(oneinputText, ccRegexInfoCode);
                }
            }

            #region

            if (matchNumber == 1) //匹配
            {

                //建立当前节点的匹配关系，但是否要挂在此级，需要继续判断它的子级
                TreeNode matchTreeNode = new TreeNode(ccName) { Name = ccId };

                bool child = false;
                //todo 判断当前节点的子节点是否存在匹配项，如果没有匹配的子节点，那当前节点才可以匹配，否则继续递归匹配子节点
                //下级不为空
                #region 下级不为空
                if (childCount > 0)
                {
                    DataRow[] arrayDr = conditiondt.Select("CC_ParentID='" + ccId + "' and CC_NodeType<>12");
                   // string strchildren = "";//子级返回
                    for (int i = 0; i < arrayDr.Length; i++)
                    {
                        bool mat = MatchChild(conditiondt, outsr, arrayDr[i]["CC_ID"].ToString(), arrayDr[i]["CC_Name"].ToString(), ccId,
                            arrayDr[i]["CC_RegexInfoCode"].ToString(),
                            Convert.ToInt32(arrayDr[i]["RegCount"].ToString()),
                            Convert.ToInt32(arrayDr[i]["ChildCount"].ToString()), ref resultText, ref matchTreeNode, ref outsr);
                        if (mat)
                        {
                            child = true;
                        }
                    }

                    #region 注释 dcy 
                    if (!child) //下级没有匹配到(没写数据不挂数据),当前节点挂数据
                    {
                        if (resultText == "")
                        {
                            resultText = ccId;

                        }
                        else
                        {
                            resultText += "," + ccId;
                        }

                        matchTreeNode.Checked = true;
                        matchTreeNode.Text = ccName;
                        matchTreeNode.Tag = ProcessNodeType.Single;
                        treeNode.Nodes.Add(matchTreeNode);

                    }
                    else
                    {
                        matchTreeNode.Checked = false;
                        matchTreeNode.Tag = ProcessNodeType.Single;
                        matchTreeNode.Text = ccName;
                        treeNode.Nodes.Add(matchTreeNode);
                    }
                    #endregion
                    return true;

                }
                #endregion
                else
                {
                    /*
                     * 下级为空，则该节点为最小节点，开始判断该节点的父节点的同级节点是否匹配，如果匹配，则继续匹配同级节点的子节点
                     */
                    DataRow[] arrayDr = conditiondt.Select("CC_ID='" + ccIdParentId + "'");
                    var ccIdGrandParentId = arrayDr[0]["CC_ParentID"].ToString();
                    
                    //当前节点的父节点的同级节点集合
                    IList<string> siblingsList = new List<string>();
                    IList<TreeNode> matchsSiblingsNodes = new List<TreeNode>();

                    var siblingsResult = MatchSiblingsNode(conditiondt, oneinputText, ccIdParentId, ccIdGrandParentId, ccId, ccName, siblingsList, matchsSiblingsNodes);
                    //同级父节点存在匹配项且子节点名称相同
                    if (siblingsResult)
                    {
                        if (resultText == "")
                        {
                            resultText = siblingsList.ListToString(",") + "," + ccId;
                        }
                        else
                        {
                            resultText += "," + ccId;
                        }


                        treeNode.Nodes.Add(new TreeNode(ccName)
                        {
                            Name = ccId,
                            Tag = ProcessNodeType.CombinationChild,
                            Text = ccName,
                            Checked = true
                        });
                        treeNode.Tag = ProcessNodeType.Combination;
                    }
                    else //同级父节点不存在匹配项或子节点名称不相同
                    {

                        treeNode.Nodes.Add(new TreeNode(ccName)
                        {
                            Name = ccId,
                            Tag = ProcessNodeType.Single,
                            Text = ccName,
                            Checked = true
                        });
                    }
                }
                return true;
            }

            #endregion

            return false;
        }

        /// <summary>
        /// 匹配同级节点及子节点
        /// </summary>
        /// <param name="conditiondt">跑表述的节点集合</param>
        /// <param name="oneinputText">表述逻辑段</param>
        /// <param name="ccId">当前节点（表述符合正则规则）</param>
        /// <param name="ccIdParentId">当前节点的父节点ID</param>
        /// <param name="ccIdChildId">当前节点的子节点ID</param>
        /// <param name="matchSiblingsIdList">匹配的同级节点集合</param>
        /// <returns>是否存在匹配的同级节点，存在，则返回true，否则返回false</returns>
        ///                     var siblingsResult = MatchSiblingsNode(conditiondt, oneinputText, ccIdParentId, ccIdGrandParentId, ccId, ccName, siblingsList, matchsSiblingsNodes);
        private bool MatchSiblingsNode(DataTable conditiondt, string oneinputText, string ccId,string ccIdParentId, string ccIdChildId,string ccName,
            IList<string> matchSiblingsIdList, IList<TreeNode> matchTreeNode)
        {

            bool isMatchSiblings = false;
            if (conditiondt != null && conditiondt.Rows.Count > 0)
            {
                //获取当前节点的同级节点,不包括当前节点
                var arrayDr =
                    conditiondt.Select("CC_ParentID='" + ccIdParentId + "' and CC_NodeType<>12 and CC_ID <> '" + ccId + "'");

              //  var sourceChildRows = conditiondt.Select("CC_ID='" + ccIdChildId + "'");
               // var sourceChildName = sourceChildRows[0]["CC_Name"].ToString();

                //不存在同级节点
                if (!arrayDr.Any())
                    return isMatchSiblings;
                else
                {
                    //循环同级节点，查看是否匹配，匹配则继续匹配同级节点的子节点
                    for (var i = 0; i < arrayDr.Length; i++)
                    {
                        var currentId = arrayDr[i]["CC_ID"].ToString();
                        var currentCcIdName = arrayDr[i]["CC_Name"].ToString();
                        var regexInfoCode = arrayDr[i]["CC_RegexInfoCode"].ToString();
                        var regexCount = Convert.ToInt32(arrayDr[i]["RegCount"].ToString());
                        //var childCount = Convert.ToInt32(arrayDr[i]["ChildCount"].ToString());

                        //同级节点有正则且匹配，则判断是否匹配该节点的子节点
                        if (regexCount > 0 && IsMatch(oneinputText, regexInfoCode) == 1)
                        {
                            var childDr = conditiondt.Select("CC_ParentID='" + currentId + "'");
                            if (!childDr.Any())
                                continue;
                            else
                            {
                                for (var j = 0; j < childDr.Length; j++)
                                {
                                    //匹配子节点,默认只取子节点的第一个，按照案例加工人员创建节点树的规则，在这个节点下是不会有两个子节点的
                                    var currentChildId = childDr[j]["CC_ID"].ToString();
                                    var childRegexInfoCode = childDr[j]["CC_RegexInfoCode"].ToString();
                                    var childName = childDr[j]["CC_Name"].ToString();
                                    var childRegexCount = Convert.ToInt32(arrayDr[i]["RegCount"].ToString());

                                    //该节点存在正则，表述匹配正则，节点名称与源节点的子节点名称相等
                                    if (childRegexCount > 0 && IsMatch(oneinputText, childRegexInfoCode) == 1 && childName==ccName)
                                    {

                                        //父节点匹配
                                        matchSiblingsIdList.Add(currentId);

                                        //插入匹配树
                                        var treeNode = new TreeNode(currentCcIdName) { Name = currentId, Tag = ProcessNodeType.Combination };
                                        treeNode.Nodes.Add(new TreeNode(childName) { Name = currentChildId, Tag = ProcessNodeType.CombinationChild, Checked = true });
                                        matchTreeNode.Add(treeNode);

                                        isMatchSiblings = true;
                                    }
                                }
                            }
                            //匹配子节点,默认只取子节点的第一个，按照案例加工人员创建节点树的规则，在这个节点下是不会有两个子节点的
                            //var currentChildId = childDr[0]["CC_ID"].ToString();
                            //var childRegexInfoCode = childDr[0]["CC_RegexInfoCode"].ToString();
                            //var childName = childDr[0]["CC_Name"].ToString();
                            //var childRegexCount = Convert.ToInt32(arrayDr[i]["RegCount"].ToString());

                            ////该节点存在正则，表述匹配正则，节点名称与源节点的子节点名称相等
                            //if (childRegexCount > 0 && IsMatch(oneinputText, childRegexInfoCode) == 1 && childName.Contains(ccName))
                            //{

                            //    //父节点匹配
                            //    matchSiblingsIdList.Add(currentId);

                            //    //插入匹配树
                            //    var treeNode = new TreeNode(currentCcIdName) { Name = currentId, Tag = ProcessNodeType.Combination };
                            //    treeNode.Nodes.Add(new TreeNode(childName) { Name = currentChildId, Tag = ProcessNodeType.CombinationChild, Checked = true });
                            //    matchTreeNode.Add(treeNode);

                            //    isMatchSiblings = true;
                            //}
                        }
                    }

                    return isMatchSiblings;
                }

            }
            return isMatchSiblings;

        }





        #endregion

        #region 正则是否匹配
        /// <summary>
        /// 正则是否匹配
        /// </summary>
        /// <param name="inputText">逻辑段</param>
        /// <param name="ccRegexInfoCode">正则单元</param>
        /// <returns></returns>
        public int IsMatch(string inputText, string ccRegexInfoCode)
        {
            try
            {
                if (getregex.IsMatch(ccRegexInfoCode, inputText))//匹配 CC_RegexInfoCode为编号
                {
                    return 1;
                }
                else
                {
                    return 0;
                }
            }
            catch (Exception)
            {

                return 0;
            }


        }
        /// <summary>
        ///  dcy 存入匹配结果
        /// </summary>
        /// <param name="inputText"></param>
        /// <param name="ccRegexInfoCode"></param>
        /// <returns></returns>
        public string strMatch(string inputText, string ccRegexInfoCode)
        {
            try
            {
                return getregex.GetParseValue(ccRegexInfoCode, inputText);
            }
            catch (Exception)
            {

                return "";
            }
        }
        #endregion

        #endregion

        #region 隐私处理
        /// <summary>
        /// 隐私处理
        /// </summary>
        /// <param name="ParagraphText"></param>
        /// <param name="CaseId"></param>
        /// <returns></returns>
        public string Privacy(string ParagraphText, string CaseId)
        {
            #region 隐私处理
            //ParagraphText = "被告人谢荣兵已经着手实施盗窃犯罪，由于意志以外的原因而未得逞，系犯罪未遂。";
            //CaseId = "1000249";
            try
            {
                string Fields = datas.ExceptAdditionalFields(CaseId).Replace("，", ",");
                Fields = Fields.Replace(",", "|").Replace("，", "|").Replace("*", @"\*").Trim();//取人名
                if (Fields != "")
                {
                    ParagraphText = System.Text.RegularExpressions.Regex.Replace(ParagraphText, Fields, "×××");//挖空人名
                }
                //ParagraphText = getregex.GetParseValue("CC1508221657230001", ParagraphText);//排除金额，多×××
                // ParagraphText = getregex.GetParseValue("CC1508211030520001", ParagraphText);//排除某些字符
                return ParagraphText;//排除某些字符

            }
            catch (Exception error)
            {
                error.ToString();
                return ParagraphText;
            }
            #endregion
        }
        #endregion

        #region 入库

        #region 组合和单一混合跑
        /// <summary>
        /// 添加表述(组合和单一跑表述)
        /// </summary>
        /// <param name="caseCauseId"></param>
        /// <param name="ccIdList"></param>
        /// <param name="resultText"></param>
        /// <param name="caseid"></param>
        /// <param name="paragraphTypeId">逻辑段类型ID</param>
        /// <param name="treeNode">匹配组合好的树节点</param>
        public void AddCombinationExpress(string resultText, string caseid, string paragraphTypeId, string caseCauseId, string ccIdList, TreeNode treeNode)
        {
            #region 第一步：添加SYS_Express_MatchSituation表

            #region 节点属性
            //bool ismatchb = getregex.IsMatch("3F53BB8A-08CC-4F55-89A9-8EAAE4FC3163", resultText);//true 不构成
            //int ismatch = ismatchb ? 0 : 1;

            int ismatch = 0; //民事没有构成不构成 todo by zhangpeng 2017-01-04

            bool affirmIdeaResultb = getregex.IsMatch("EI1601201151020001", resultText);//true 认定不认定
            string affirmIdeaResult = affirmIdeaResultb ? "2" : "1";
            SYS_Express_MatchSituation stiuModel = new SYS_Express_MatchSituation
            {
                IsMatch = ismatch,
                MatchSource = "0",
                AffirmIdeaResult = affirmIdeaResult,
                AffirmIdeaSource = "0"
            };

            #endregion

            string msId = "";
            string allCombinePid = "";
            string allMsIdPid = "";

            /* 判断是组合或单一
             * 组合的条件（民事）：
             * a.在指定节点范围内，在此以争议焦点要素为例，一条表述按照父子关系，层层往下跑，如果符合父级规则，则继续往下漏，
             *   当跑到最后一级如果符合，则去匹配该节点的父级的同级节点，如果也符合，则跑到符合的同级节点的子节点，如果子节点符合，并且名称与第一个子节点的名称一样，则他俩的父节点组合，表述挂到子节点上
             *   如：‘111’这条表述既符合，<按约提供物业合同>下的<支持物业>，也符合<符合法律规定>下的<支持物业>，则组合<按月提供物业合同+符合法律规定>，同时表述挂在组合节点下的<支持物业>上。
             * b.能组合的节点的父节点一定是同一个节点，不能越级，组合节点都是平级，不同于刑事的层层往下进行组合。
             *   如：<按约提供物业合同>和<符合法律规定>两个节点的子节点名称相同，并且表述都符合子节点的规则，同时这两个节点的父节点是同一节点，则这两个节点才可以组合
             */

            //添加Match和表述
            InsertMatch(treeNode, caseCauseId, allCombinePid, allMsIdPid, stiuModel, msId, new Tuple<string, string, string>(caseid, paragraphTypeId, resultText));



            ////组合情形
            //string[] situationIDa = ccIdList.Split(',');

            //if (situationIDa.Length > 0)
            //{
            //    allCombinePid = situationIDa[0];
            //    allMsIdPid = "";
            //    msId = work.AddMatch(situationIDa[0], caseCauseId, allCombinePid, caseCauseId, stiuModel, allMsIdPid, false);
            //    for (int i = 1; i < situationIDa.Length; i++)
            //    {
            //        allCombinePid = allCombinePid + "," + situationIDa[i];
            //        if (allMsIdPid != "")
            //            allMsIdPid += "," + msId;
            //        else
            //            allMsIdPid += msId;
            //        msId = work.AddMatch(situationIDa[i], msId, allCombinePid, caseCauseId, stiuModel, allMsIdPid, false);
            //    }
            //}
            #endregion




        }




        /// <summary>
        /// 添加Match和表述（组合和单一混合跑）
        /// </summary>
        /// <param name="parentNode">父节点</param>
        /// <param name="causeGroupId">情形情节ID</param>
        /// <param name="allCombinePid">组合IDs</param>
        /// <param name="allMsIdPid"></param>
        /// <param name="stiuModel"></param>
        /// <param name="msId"></param>
        /// <param name="caseInfoTuple">案例元组信息</param>
        /// <returns></returns>
        private void InsertMatch(TreeNode parentNode, string causeGroupId, string allCombinePid, string allMsIdPid, SYS_Express_MatchSituation stiuModel, string msId, Tuple<string, string, string> caseInfoTuple)
        {
            //判断树
            if (parentNode != null && !string.IsNullOrEmpty(parentNode.Name))
            {
                #region 判断条件
                if (string.IsNullOrEmpty(allCombinePid))
                    allCombinePid = parentNode.Name;
                else
                {
                    allCombinePid += "," + parentNode.Name;
                }

                if (string.IsNullOrEmpty(allMsIdPid) && string.IsNullOrEmpty(msId))
                    allMsIdPid = "";
                else if (string.IsNullOrEmpty(allMsIdPid))
                {
                    allMsIdPid += msId;
                }
                else
                {
                    allMsIdPid += "," + msId;
                }
                #endregion

                //代表选择的根节点
                if (parentNode.Name == causeGroupId)
                {
                    if (parentNode.Checked)
                        msId = work.AddMatch(parentNode.Name, string.IsNullOrEmpty(msId) ? causeGroupId : msId, allCombinePid, causeGroupId, stiuModel, allMsIdPid, false);
                }
                else
                {
                    msId = work.AddMatch(parentNode.Name, string.IsNullOrEmpty(msId) ? causeGroupId : msId, allCombinePid, causeGroupId, stiuModel, allMsIdPid, false);
                }


                //存在子节点
                if (parentNode.Nodes.Count > 0)
                {
                    //同级存在多个子节点，有可能是组合
                    if (parentNode.Nodes.Count > 1)
                    {
                        //判断第一个子节点是否存在子节点，如果有子节点，子节点的类型是否是组合子节点类型
                        if (parentNode.Nodes[0].Nodes.Count > 0 && (ProcessNodeType)parentNode.Nodes[0].Nodes[0].Tag == ProcessNodeType.CombinationChild)
                        {
                            var ccId = parentNode.Nodes[0].Name;//组合节点
                            var situationName = string.Empty;//组合名称
                            var childCcIds = string.Empty;
                            var childCcName = string.Empty;
                            foreach (TreeNode node in parentNode.Nodes)
                            {
                                if (node.Nodes.Count > 0 && (ProcessNodeType)node.Nodes[0].Tag == ProcessNodeType.CombinationChild)
                                {
                                    allCombinePid += string.IsNullOrEmpty(allCombinePid) ? node.Name : "," + node.Name;
                                    situationName += string.IsNullOrEmpty(situationName) ? ccbll.GetCaseCauseByCCID(node.Name).CC_Name : "+" + ccbll.GetCaseCauseByCCID(node.Name).CC_Name;
                                    allMsIdPid += string.IsNullOrEmpty(allMsIdPid) ? msId : "," + msId;
                                    if (node.Nodes.Count > 0)
                                    {
                                        childCcIds += string.IsNullOrEmpty(childCcIds) ? node.Nodes[0].Name : "," + node.Nodes[0].Name;
                                    }
                                    childCcName = ccbll.GetCaseCauseByCCID(node.Nodes[0].Name).CC_Name;
                                }
                            }

                            msId = work.AddCivilMatch(ccId, situationName, string.IsNullOrEmpty(msId) ? causeGroupId : msId, allCombinePid, causeGroupId, stiuModel, allMsIdPid);
                            if (!string.IsNullOrEmpty(msId))
                            {
                                var childMsId = work.AddCivilMatch(parentNode.Nodes[0].Nodes[0].Name, childCcName, string.IsNullOrEmpty(msId) ? causeGroupId : msId, (allCombinePid + "," + childCcIds), causeGroupId, stiuModel, allMsIdPid);
                                //添加表述，组合表述
                                AddExpressWordProcess_Combination(childMsId, caseInfoTuple.Item1, caseInfoTuple.Item3,
                        caseInfoTuple.Item2);
                            }
                            else
                            {

                            }

                        }
                        else  //不是组合节点，则继续循环
                        {
                            foreach (TreeNode node in parentNode.Nodes)
                            {
                                InsertMatch(node, causeGroupId, allCombinePid, allMsIdPid, stiuModel, msId, caseInfoTuple);
                            }
                        }


                    }
                    else //子节点数量为1
                    {
                        InsertMatch(parentNode.Nodes[0], causeGroupId, allCombinePid, allMsIdPid, stiuModel, msId, caseInfoTuple);
                    }

                }
                else //没有子节点
                {
                    //直接添加表述，且是单一表述
                    AddExpressWordProcess_Combination(msId, caseInfoTuple.Item1, caseInfoTuple.Item3,
                        caseInfoTuple.Item2);
                }
            }

        }

        /// <summary>
        /// 添加表述文本SYS_Express_Word_Process
        /// </summary>
        /// <param name="msId"></param>
        /// <param name="caseId"></param>
        /// <param name="inputText"></param>
        /// <param name="paragraphTypeId"></param>
        private void AddExpressWordProcess_Combination(string msId, string caseId, string inputText,
            string paragraphTypeId)
        {
            SYS_Express_Word wordModel = new SYS_Express_Word
            {
                MS_ID = msId,
                EW_CaseId = caseId,
                EW_Content = inputText,
                EW_UseCount = 1,
                EW_WordCount = inputText.Length,
                ParagraphTypeId = Convert.ToInt32(paragraphTypeId)
            };
            //判断表述是否存在
            wordModel.EW_ID = wordbll.Exists_WordProcess(wordModel);

            if (wordModel.EW_ID == "")
            {
                wordModel.EW_ID = newid.JudgeDoc_CreateID("SYS_Express_Word");
                wordModel.EW_Right = 0;
                wordModel.EW_Wrong = 0;
                wordbll.AddWord_Process(wordModel);
            }
            else
            {
                wordbll.UpdateWord_Process(wordModel);
            }
        }

        #endregion


        #region 只跑单一


        /// <summary>
        /// 添加表述
        /// </summary>
        /// <param name="caseCauseId"></param>
        /// <param name="ccIdList"></param>
        /// <param name="resultText"></param>
        /// <param name="caseid"></param>
        /// <param name="paragraphTypeId">逻辑段类型ID</param>
        public void AddToExpress(string resultText, string caseid, string paragraphTypeId, string caseCauseId, string ccIdList, string EW_Content)
        {
            #region 第一步：添加SYS_Express_MatchSituation表

            #region 节点属性
            //bool ismatchb = getregex.IsMatch("3F53BB8A-08CC-4F55-89A9-8EAAE4FC3163", resultText);//true 不构成
            //int ismatch = ismatchb ? 0 : 1;

            int ismatch = 0; //民事没有构成不构成 todo by zhangpeng 2017-01-04

            bool affirmIdeaResultb = getregex.IsMatch("EI1601201151020001", resultText);//true 认定不认定
            string affirmIdeaResult = affirmIdeaResultb ? "2" : "1";
            SYS_Express_MatchSituation stiuModel = new SYS_Express_MatchSituation
            {
                IsMatch = ismatch,
                MatchSource = "0",
                AffirmIdeaResult = affirmIdeaResult,
                AffirmIdeaSource = "0"
            };

            #endregion
            string msId = "";
            string allCombinePid = "";
            string allMsIdPid = "";
            //组合情形

            string[] situationIDa = ccIdList.Split(',');

            if (situationIDa.Length > 0)
            {
                allCombinePid = situationIDa[0];
                allMsIdPid = "";
                msId = work.AddMatch(situationIDa[0], caseCauseId, allCombinePid, caseCauseId, stiuModel, allMsIdPid, false);
                for (int i = 1; i < situationIDa.Length; i++)
                {
                    allCombinePid = allCombinePid + "," + situationIDa[i];
                    if (allMsIdPid != "")
                        allMsIdPid += "," + msId;
                    else
                        allMsIdPid += msId;
                    msId = work.AddMatch(situationIDa[i], msId, allCombinePid, caseCauseId, stiuModel, allMsIdPid, false);
                }
            }
            #endregion

            #region 第二步：添加表述文本SYS_Express_Word_Process

            SYS_Express_Word wordModel = new SYS_Express_Word
            {
                MS_ID = msId,
                EW_CaseId = caseid,
                EW_Content = EW_Content,
                EW_UseCount = 1,
                EW_WordCount = resultText.Length,
                ParagraphTypeId = Convert.ToInt32(paragraphTypeId)
            };



            wordModel.EW_ID = wordbll.Exists_WordProcess(wordModel);

            if (wordModel.EW_ID == "")
            {
                wordModel.EW_ID = newid.JudgeDoc_CreateID("SYS_Express_Word");
                wordModel.EW_Right = 0;
                wordModel.EW_Wrong = 0;
                wordModel.UpdateTime = DateTime.Now;
                wordbll.AddWord_Process(wordModel);
            }
            else
            {
                wordModel.UpdateTime = DateTime.Now;
                wordbll.UpdateWord_Process(wordModel);
            }
            #endregion

            //#region 词库
            //List<string> EW_AddElementStr = express_wordbankrelbll.WordBank("", WordModel.EW_Content);

            //foreach (var item in EW_AddElementStr)
            //{
            //    if (!express_wordbankrelbll.Exists(WordModel.EW_ID, item))
            //    {
            //        express_wordbankrelbll.Add_Express_WordBankRel(newid.JudgeDoc_CreateID("SYS_Express_WordBankRel"), WordModel.EW_ID, item);
            //    }
            //}
            //#endregion
        }


        #endregion



        #endregion
    }
}